
{/* banner prompt: A playful, polished 3D clay-render in matte sage green, cream and terracotta: a stylized NVIDIA RTX 3060 graphics card, and a cute rounded clay whale with a faint glowing cyan wireframe pattern on its side, swimming above a row of three small rounded screens each showing a tiny version of the same whale, tiny clapperboard and soft concentric sound-wave props, soft studio shadows, simple pale cream background, gentle depth of field, warm muted palette, no text, no people, 16:9. */}

Our homepage has an electric whale, a glowing cyan wireframe humpback swimming through a digital ocean, playing behind the headline. It was made for a wide desktop screen, so on a phone it gets cropped to a sliver. We wanted a proper **portrait** version for mobile, and it turned into a small experiment worth writing down: take *one* keyframe and hand it to three different video models (one running locally on our RTX 3060, and two frontier models in the cloud) then judge them honestly.

The twist, as usual, is that "cheapest," "best-looking," and "the one we actually shipped" were three different answers.

## The setup: one keyframe, three animators

Everything starts from a single still. We generated a 9:16 keyframe on the same RTX 3060 that runs the rest of this series: a cyan low-poly wireframe whale over a glowing data grid, with a magenta flare and purple depth to match the original. Then that identical image went, unchanged, into each of the three models as the first frame. Same whale, same starting composition; only the motion model changes.

That is the fair way to compare image-to-video: hold the input constant and watch what each model *does* with it.

## MiniMax H3: local, free, and it actually works

First, the home team. [MiniMax H3](/blog/2026/08/04-now-it-talks-open-source-video-with-sound-on-the-same-rtx-3060/) is an open-weights model we already run locally, streaming its 50-odd GB of weights through a 12GB card a slice at a time.

<YouTube id="xaG_naHmBPg" />

The result is genuinely good: the whale swims with a real, gentle tail undulation and the model even grows its own drifting data-particles by the end. It is coherent, on-style, and it cost nothing but electricity and patience: **about 20 minutes for a 3-second clip at 512×896**. That is the honest local trade-off: free and completely private, but slow, shorter, and lower-resolution than the cloud. As a proof that a consumer card can do this at all, it's a quiet triumph.

## Veo 3.1: the calm, cinematic one

Next, Google's Veo 3.1 Fast, through the Gemini API, from the exact same keyframe.

<YouTube id="k-lnccxtRPM" />

This is where the jump in production value shows. In **under a minute** and for **a dollar or two**, Veo returned a smooth **720×1280, 8-second** clip and, unprompted, built an entire digital ocean around the whale: a rippling grid, parallax depth, drifting stars. The motion is calm and ambient, which matters when the video lives *behind* a headline. It never fights the text. This is the one we shipped.

## Sora 2: the most beautiful, and the one on a clock

Finally, OpenAI's Sora 2, same keyframe again.

<YouTube id="00272-n56_Q" />

On pure craft, Sora 2 makes the best whale of the three. The wireframe mesh is the most refined, and the motion is the most lifelike: a graceful full-body dive with fins and flukes that move like they have weight. It was also the cheapest of the cloud runs (~$0.80 for 8 seconds) and quick (~2 minutes).

There are two catches. First, that gorgeous, dramatic motion is *busier*: stunning as a hero, harder to sit quietly behind text. Second, and decisively for us: **OpenAI's Sora 2 video API stops accepting requests on 24 September 2026.** Building a banner on an API that disappears next week is not a plan.

## A quick colour lesson

One thing the experiment taught us: image models have opinions. Our first keyframes came out pure cyan on black; the model kept stripping the magenta flare and purple wash that give the original its identity. No amount of prompting fixed it; the model simply preferred cyan. The fix was to stop arguing and **composite the magenta back in**, with a flare and a purple gradient added to the keyframe in a few lines of code. Every model then faithfully carried that palette through the animation. Sometimes the right move is to give the model a picture, not an argument.

## The verdict

| | Where | Best at | The catch |
|---|---|---|---|
| **MiniMax H3** | Local, RTX 3060 | Free, private, no API | Slow, short, lower-res |
| **Veo 3.1** | Google, cloud | Calm, cinematic, ambient | Paid per second |
| **Sora 2** | OpenAI, cloud | Most beautiful, most lifelike | API shuts down 24 Sep 2026 |

If you want free and private, the local model already does it. If you want the most beautiful single clip, Sora 2 wins, for just a few more days. But for a banner that has to loop quietly behind a headline *and* still be regenerable next month, **Veo 3.1 was the right tool**, and it's the whale now swimming on our homepage when you open [tyolab.com](https://www.tyolab.com) on your phone.

The best-looking model and the right one are rarely the same tool. We keep relearning that, one whale at a time.


73bc0aaa8e4b0dc73db4d84553a272335700c09c3dd7bbe5c44daf14837c854d

A hands-on comparison of MiniMax H3 (local, RTX 3060), Google Veo 3.1 and OpenAI Sora 2 for image-to-video, all from one shared keyframe, judged on motion, fidelity, speed, cost and which API will still exist next week.

We wanted a portrait version of the electric whale on our homepage, so we animated the same AI-generated keyframe with a local model on our RTX 3060 and two frontier cloud models. Free-and-private, best-and-sustainable, and best-looking turned out to be three different answers.

One Whale, Three Video Models: MiniMax H3 vs Veo 3.1 vs Sora 2

{/* banner prompt: A playful, polished 3D clay-render in matte sage green, cream and terracotta: a stylized NVIDIA RTX 3060 graphics card as a tiny cinema, a small strip of film curling out of it, and a rounded speaker or sound-wave motif beside it emitting soft concentric rings to show the video now has audio; a little clapperboard prop, soft studio shadows, simple background, 16:9. */}

I ended the [last post](/blog/2026/08/03-now-it-moves-video-generation-on-the-same-rtx-3060/)
with a promise: the same RTX 3060 that learned to make short video would next try
to make video *with sound*, using **MiniMax H3**, an open-weights model that
generates its own audio. The weights landed publicly, I put them on the same
card, and this is what actually happened.

The headline first: it works. A single product photo goes in, and a few-second
clip comes out: the model turning, the fabric settling, a soft spoken line and
room tone, **audio the model generated itself**, not dubbed on afterwards. On a
12GB consumer card. That part genuinely surprised me.

## The machine (still the same one)

Same box as the [image retrospective](/blog/2026/08/03-two-years-of-open-source-image-ai-on-one-rtx-3060/)
and the [video post](/blog/2026/08/03-now-it-moves-video-generation-on-the-same-rtx-3060/):
an RTX 3060 with 12GB of VRAM, 64GB of system RAM, Debian. Nothing upgraded. The
card is the constant this whole series is built around.

## What "video with sound" means here

Most open video models are mute. You get moving pictures and add sound in an
editor. MiniMax H3 is different: video and audio come out of the *same* model,
generated together, so the soundtrack matches the scene. Describe waves and a
spoken line, and you get waves and a voice. That single capability is why it was
worth the effort.

## Fitting 54GB into 12GB

Here is the honest part. H3 is big: about **54GB of weights**, a 21GB video
model, a 27GB text encoder, and two decoders for picture and sound. That does
not fit in 12GB of VRAM. Not close.

It runs anyway because the weights live in the 64GB of system RAM and stream onto
the card a slice at a time, keeping just enough on the GPU to do the next step.
It is slow, but it finishes. Two smaller things also got in the way: the model is
new enough that its picture and sound decoders each had a small bug that had to
be patched before a clip would complete, and the card needed a healthy slice of
memory kept free so the compressed weights had room to unpack. Fiddly, but
one-time; once it was set up, it just ran.

## The result: a product clip that turns and talks

This is the workflow a small business would actually use: start from one product
photo, and let the model animate it: the person turns to camera, the knit
settles, a quiet line of audio plays, while the product stays readable. Here is
a real clip generated on this card. **Press play with the sound on**: the audio
came out of the model, not an editor.

<video controls playsInline preload="metadata" poster="https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/08/now-it-talks-open-source-video-with-sound-on-the-same-rtx-3060/sweater-poster.png" style={{ display: "block", width: "100%", maxWidth: "340px", margin: "1.5rem auto", borderRadius: "10px" }}>
  <source src="https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/08/now-it-talks-open-source-video-with-sound-on-the-same-rtx-3060/sweater-clip.mp4" type="video/mp4" />
</video>

And the same clip laid out frame by frame: a natural turn from side-on to
camera, the knit texture and anatomy holding through the whole move:

![Frames from a MiniMax H3 clip: a model in a cream knit sweater turning to camera, generated with sound on an RTX 3060](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/08/now-it-talks-open-source-video-with-sound-on-the-same-rtx-3060/filmstrip-sweater.png)

## The honest numbers

<Table data={
    {
        headers: ['', 'On the RTX 3060'],
        rows: [
            ['Clip length', 'A few seconds (2-5s)'],
            ['Resolution', '512-640px'],
            ['Audio', 'Yes - native stereo, generated with the video'],
            ['Model size', '~54GB of weights, streamed from system RAM'],
            ['Time per clip', 'Roughly 20-27 minutes'],
            ['Best for', 'A short product clip with a voice or ambient soundtrack'],
        ]
    }
} />

Twenty-odd minutes for a few seconds is the real cost of streaming that much
weight through a small card. This is not something you batch out by the hundred
on a 3060. It is something you run overnight for one good clip. But the clip has
sound, and it cost electricity.

## What I learned about the "AI look"

The most useful lesson wasn't about speed. It was about *why* AI video still
reads as AI, and how to fight it.

Image-to-video can never look better than the photo you start from; it inherits
that frame's every quirk and then adds motion on top. My first attempts started
from bright, high-contrast outdoor stills, and they had that unmistakable
"AI feel": waxy skin, hard outlines, the joins between body parts subtly wrong.
The motion clung to those hard edges and made them worse.

The clip above started from a **soft, studio-lit photo** instead: diffused
light, a plain background, gentle edges. And it held together: real fabric
texture, natural movement, believable anatomy through the whole turn. Same model,
same card, completely different result.

So the practical rule, if you try this yourself: **start from soft, evenly-lit
photos, not harsh high-contrast ones.** The model can't cling to hard edges that
were never there. It's the single biggest lever on how "real" the output looks,
bigger than any setting.

## Where this leaves a small business

Three posts, one unchanged computer. The same RTX 3060 went from struggling with
a single 512px [still](https://www.tyolab.com/prompts), to short
[silent video](/blog/2026/08/03-now-it-moves-video-generation-on-the-same-rtx-3060/),
to a short clip **with its own soundtrack**: a product turning to camera and
speaking a line, generated from one photo, locally, for the cost of the power it
drew.

It is not one-click, and it is not fast. But the gap between "I have a product
photo" and "I have a short product video with sound" has quietly closed on
hardware a small business can already afford. That's the whole point of this
series: the tools that used to need a studio now need a modest computer and a bit
of patience.

*The card hasn't changed in two years. What it can do has.*


6346af2d42f415c4ca54fcaccf751257edbd3e81b952309f0c8a4adbe7c74d0d

Running MiniMax H3, an open-source video model with native audio, on a consumer RTX 3060 12GB: how 54GB of weights fit in 12GB, honest generation times, the quality limits, and turning one product photo into a clip with sound.

The third in our RTX 3060 series. MiniMax H3, an open-weights video model that generates its own audio, runs on the same 12GB card: a product clip with a real soundtrack, from a single photo, generated locally.

Now It Talks: Open-Source Video With Sound on the Same RTX 3060

{/* banner prompt: A playful but polished 3D clay-render, matte materials in sage green, cream and terracotta, of a stylized NVIDIA RTX 3060 graphics card acting as a small film projector on a simple background, casting a beam of light onto a tiny cinema screen that shows a strip of film frames; a couple of small clapperboard and film-reel props beside it, soft studio shadows, 16:9. */}

In the [last post](/blog/2026/08/03-two-years-of-open-source-image-ai-on-one-rtx-3060/)
I traced how open-source *image* generation went from a 512px struggle to
photoreal Flux on one RTX 3060. I ended it with a tease about video. Here's the
payoff, and it's the part that genuinely surprised me.

Two years ago, generating video on a consumer graphics card wasn't really a
thing; the early attempts were a few flickery, warping frames. The **same RTX
3060** now produces short, coherent clips and, more usefully for a small
business, it can take a **single product photo and turn it into a promo**.

## The machine (still the same one)

Same box as the [image post](/blog/2026/08/03-two-years-of-open-source-image-ai-on-one-rtx-3060/)
and the [LLM benchmark](/blog/2026/05/11-64gb-ram-12gb-vram-the-honest-local-llm-benchmark/):
an RTX 3060 with 12GB of VRAM, 64GB of system RAM, Debian 13. Nothing upgraded.

## What runs today

Two open models do the heavy lifting, both locally:

- **Wan 2.2**: higher quality, does text-to-video *and* image-to-video. Slower.
- **LTX-Video**: faster and lighter, good for quick drafts.

The 12GB card can't touch the giant cloud video models, but with the weights
quantised and the text encoder offloaded to system RAM, these run, a few
seconds of 480–832px video per clip.

## The trick that matters: one photo becomes a promo

This is the workflow a small business will actually use. Generate a product
photo (or use one you already have), then animate *it*: the model, the fabric,
the light all start moving, while the product stays put. Each strip below is
frames from a real clip, and each one started as a single still generated on
this same card.

A knit sweater: the model turns to camera, hair catching a breeze.

![Frames from the sweater promo clip](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/08/now-it-moves-video-generation-on-the-same-rtx-3060/filmstrip-sweater.png)

Sunscreen, very on-brand for an Australian summer, the product held steady in
focus while the scene breathes:

![Frames from the sunscreen promo clip](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/08/now-it-moves-video-generation-on-the-same-rtx-3060/filmstrip-sunscreen.png)

And eyewear, a slow confident turn in golden-hour light:

![Frames from the sunglasses promo clip](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/08/now-it-moves-video-generation-on-the-same-rtx-3060/filmstrip-shades.png)

## The honest numbers

<Table data={
    {
        headers: ['', 'On the RTX 3060'],
        rows: [
            ['Clip length', 'A few seconds (2-5s)'],
            ['Resolution', '480p to ~832px'],
            ['Time per clip (Wan 2.2)', 'Roughly 4-8 minutes'],
            ['Time per clip (LTX)', 'Under a minute for a short draft'],
            ['Best for', 'Image-to-video product promos, social clips'],
            ['Audio', 'Not yet; these models are silent'],
        ]
    }
} />

It's not one-click cinema. Big, fast motion still warps; the sweet spot is
*subtle* movement (a turn of the head, a breeze, a slow push) with the product
kept steady. You generate a couple of takes and keep the best, same as with
stills. But a usable, on-brand product clip in a few minutes, for the cost of
the electricity, on a card that couldn't manage one clean still two years ago,
that's the shift.

## What's next: sound

The current open video models are mute. The next one on our bench, **MiniMax
H3**, ships open weights *with* native audio and is reported to run on exactly
this class of hardware. When its weights land publicly, we'll put it on the same
3060 and see whether a small business can generate a product clip **with a
soundtrack** end to end, and we'll write up what actually happens.

For now, the takeaway from two posts and one unchanged GPU: the same modest
computer that makes studio-grade [stills](https://www.tyolab.com/prompts) now
makes short video too, and the gap between "I have a product photo" and "I have a
product video" has quietly closed.

*Next up: MiniMax H3, open-weights video with sound, on the very same card.*


f0674b5bd369cc5974a7176ec4a2cabacc5a46b250c255ade9ac44cf34a8f0d1

How open-source video generation runs on a consumer RTX 3060 12GB in 2026: Wan 2.2 and LTX-Video for text-to-video and image-to-video, real generation times, VRAM limits, and a worked example turning a product photo into a promo clip.

The follow-up to our image retrospective: the same RTX 3060 that struggled with a single 512px still two years ago now generates short video, including product promos animated from a single photo, with open models like Wan 2.2 and LTX-Video.

Tag: Video Generation